const express = require('express');
const path = require('path');
const app = express();
const morgan = require('morgan');
const fs = require('fs');
const https = require('https');
const port = 3000;
const httpsPort = 3001;
const axios = require('axios'); 

// 使用 morgan 记录所有请求
app.use(morgan('combined'));

// 增加请求体大小限制
app.use(express.json({ limit: '50mb' }));
app.use(express.urlencoded({ limit: '50mb', extended: true }));

// 读取SSL证书文件
const options = {
  key: fs.readFileSync(path.join(__dirname, 'cert', 'server.key')),
  cert: fs.readFileSync(path.join(__dirname, 'cert', 'server.crt'))
};

const DJANGO_SERVER_URL = 'http://django-service:8000';
app.get('/api/mission_info_list/', async (req, res) => {
    const type = req.query.type; // 获取前端传来的type参数
    try {
        const response = await axios.get(`${DJANGO_SERVER_URL}/api/mission_info_list/`,{
            params: { type } // 将type作为查询参数传递给Django服务器
        });
        const missionList = response.data;
        res.json(missionList);
    } catch (error) {
        console.error('Error fetching data from Django API:', error);
        res.status(500).send('Server Error');
    }
});


app.get('/api/mission_info/', async (req, res) => {
    try {
        const missionId = req.query.id;
        // 向Django服务器转发请求
        const response = await axios.get(`${DJANGO_SERVER_URL}/api/mission_info/`, {
            params: { id: missionId }
        });
        // 将响应结果返回给前端
        res.json(response.data);
    } catch (error) {
        console.error('Error while fetching data from Django server:', error);
        res.status(500).send('Internal Server Error');
    }
});

app.get('/api/next_mission_info/', async (req, res) => {
    try {
        // 向Django服务器转发请求
        const response = await axios.get(`${DJANGO_SERVER_URL}/api/next_mission_info/`);
        // 将响应结果返回给前端
        res.json(response.data);
    } catch (error) {
        console.error('Error while fetching data from Django server:', error);
        res.status(500).send('Internal Server Error');
    }
});
const jsonData1 = {
    "author": "作者名字", 
    "title": "文章标题",
    "content": [
        {
            "type": "h1",
            "content": "任务介绍"
        },
        {
            "type": "h2",
            "content": "任务目标"
        },
        {
            "type": "p",
            "content": "Starship目前瞄准明天06:00-07:00进行第七次试飞。根据天气预报显示，明天的天气相较于今天有着较大改善，风力显著减弱，且能见度较好。\nStarship第七次试飞的主要升级几乎覆盖整个二级。..."
        },
        {
            "type": "img",
            "url": "/images/test07.jpg"
        }
    ]
};


app.get('/api/mission_details/', async (req, res) => {
    try {
        // 向 Django 服务器转发请求
        const response = await axios.get(`${DJANGO_SERVER_URL}/api/mission_details/`, {
            params: req.query, 
        });

        // 将 Django 的响应直接返回给前端
        res.status(response.status).json(response.data);
    } catch (error) {
        // 处理错误
        if (error.response) {
            // 如果 Django 返回了错误状态码（如 400、404），直接返回给前端
            res.status(error.response.status).json(error.response.data);
        } else {
            // 如果是网络错误或其他问题，返回 500 Internal Server Error
            console.error('Error while fetching data from Django server:', error.message);
            res.status(500).send('Internal Server Error');
        }
    }
});

app.get('/api/launch_statistics/', async (req, res) => {
    try {
        // 向 Django 服务器转发请求
        const response = await axios.get(`${DJANGO_SERVER_URL}/api/launch_statistics/`, {
            params: req.query, 
        });

        // 将 Django 的响应直接返回给前端
        res.status(response.status).json(response.data);
    } catch (error) {
        // 处理错误
        if (error.response) {
            // 如果 Django 返回了错误状态码（如 400、404），直接返回给前端
            console.error('Error while fetching data from Django server:', error.message);
            res.status(error.response.status).json(error.response.data);
        } else {
            // 如果是网络错误或其他问题，返回 500 Internal Server Error
            console.error('Error while fetching data from Django server:', error.message);
            res.status(500).send('Internal Server Error');
        }
    }
});

app.get('/api/related_group_missions/', async (req, res) => {
    try {
        // 向 Django 服务器转发请求
        const response = await axios.get(`${DJANGO_SERVER_URL}/api/related_group_missions/`, {
            params: req.query, 
        });

        // 将 Django 的响应直接返回给前端
        res.status(response.status).json(response.data);
    } catch (error) {
        // 处理错误
        if (error.response) {
            // 如果 Django 返回了错误状态码（如 400、404），直接返回给前端
            console.error('Error while fetching data from Django server:', error.message);
            res.status(error.response.status).json(error.response.data);
        } else {
            // 如果是网络错误或其他问题，返回 500 Internal Server Error
            console.error('Error while fetching data from Django server:', error.message);
            res.status(500).send('Internal Server Error');
        }
    }
});

app.get('/api/article_details/', (req, res) => {
    res.json(jsonData1);
});
// app.get('/api/mission_details_brief_intro/', (req, res) => {
//     res.json(jsonData2);
// });

app.get('/api/mission_details_brief_intro/', async (req, res) => {
    try {
        // 向 Django 服务器转发请求
        const response = await axios.get(`${DJANGO_SERVER_URL}/api/mission_details_brief_intro/`, {
            params: req.query, 
        });

        // 将 Django 的响应直接返回给前端
        res.status(response.status).json(response.data);
    } catch (error) {
        // 处理错误
        if (error.response) {
            // 如果 Django 返回了错误状态码（如 400、404），直接返回给前端
            console.error('Error while fetching data from Django server:', error.message);
            res.status(error.response.status).json(error.response.data);
        } else {
            // 如果是网络错误或其他问题，返回 500 Internal Server Error
            console.error('Error while fetching data from Django server:', error.message);
            res.status(500).send('Internal Server Error');
        }
    }
});

app.get('/api/launch_site_detail/', async (req, res) => {
    try {
        // 向 Django 服务器转发请求
        const response = await axios.get(`${DJANGO_SERVER_URL}/api/launch_site_detail/`, {
            params: req.query, 
        });

        // 将 Django 的响应直接返回给前端
        res.status(response.status).json(response.data);
    } catch (error) {
        // 处理错误
        if (error.response) {
            // 如果 Django 返回了错误状态码（如 400、404），直接返回给前端
            console.error('Error while fetching data from Django server:', error.message);
            res.status(error.response.status).json(error.response.data);
        } else {
            // 如果是网络错误或其他问题，返回 500 Internal Server Error
            console.error('Error while fetching data from Django server:', error.message);
            res.status(500).send('Internal Server Error');
        }
    }
});
// 文章内容组详情 API
app.get('/api/article_group_detail/', async (req, res) => {
    try {
        // 向 Django 服务器转发请求
        const response = await axios.get(`${DJANGO_SERVER_URL}/api/article_group_detail/`, {
            params: req.query, 
        });

        // 将 Django 的响应直接返回给前端
        res.status(response.status).json(response.data);
    } catch (error) {
        // 处理错误
        if (error.response) {
            // 如果 Django 返回了错误状态码（如 400、404），直接返回给前端
            console.error('Error while fetching article group data from Django server:', error.message);
            res.status(error.response.status).json(error.response.data);
        } else {
            // 如果是网络错误或其他问题，返回 500 Internal Server Error
            console.error('Error while fetching article group data from Django server:', error.message);
            res.status(500).send('Internal Server Error');
        }
    }
});

// 百科内容组详情 API
app.get('/api/encyclopedia_group_detail/', async (req, res) => {
    try {
        // 向 Django 服务器转发请求
        const response = await axios.get(`${DJANGO_SERVER_URL}/api/encyclopedia_group_detail/`, {
            params: req.query, 
        });

        // 将 Django 的响应直接返回给前端
        res.status(response.status).json(response.data);
    } catch (error) {
        // 处理错误
        if (error.response) {
            // 如果 Django 返回了错误状态码（如 400、404），直接返回给前端
            console.error('Error while fetching encyclopedia group data from Django server:', error.message);
            res.status(error.response.status).json(error.response.data);
        } else {
            // 如果是网络错误或其他问题，返回 500 Internal Server Error
            console.error('Error while fetching encyclopedia group data from Django server:', error.message);
            res.status(500).send('Internal Server Error');
        }
    }
});

// // 启动服务器
// app.listen(port, () => {
//     console.log(`Server is running at http://localhost:${port}/`);
// });

const sqlite3 = require('sqlite3').verbose();
const bodyParser = require('body-parser');
const DB_PATH = '/shared/newdb.sqlite3'; // 共享卷路径
app.use(bodyParser.json());

app.post('/tool/describe_table', (req, res) => {
  const { table } = req.body;
  if (!table) {
    return res.status(400).json({ error: '缺少表名参数' });
  }
  const db = new sqlite3.Database(DB_PATH);
  db.all(`PRAGMA table_info(${table})`, [], (err, rows) => {
    db.close();
    if (err) {
      return res.status(500).json({ error: err.message });
    }
    res.json(rows);
  });
});

app.post('/tool/query', (req, res) => {
  const { sql, params } = req.body;
  if (!sql) {
    return res.status(400).json({ error: '缺少SQL语句' });
  }
  const db = new sqlite3.Database(DB_PATH);
  db.all(sql, params || [], (err, rows) => {
    db.close();
    if (err) {
      return res.status(500).json({ error: err.message });
    }
    res.json(rows);
  });
});


// 启动HTTP服务器
app.listen(port, () => {
    console.log(`HTTP Server is running at http://localhost:${port}/`);
});

// 启动HTTPS服务器
https.createServer(options, app).listen(httpsPort, () => {
    console.log(`HTTPS Server is running at https://localhost:${httpsPort}/`);
});


// 发射场列表API转接
app.get('/api/launch_sites/', async (req, res) => {
  try {
    console.log('转接发射场列表请求到Django服务器');
    
    const response = await axios.get(`${DJANGO_SERVER_URL}/api/launch_sites/`, {
      params: req.query,  // 转发查询参数
      timeout: 10000
    });
    
    res.json(response.data);
  } catch (error) {
    console.error('发射场列表API转接错误:', error.message);
    
    if (error.response) {
      res.status(error.response.status).json(error.response.data);
    } else {
      res.status(500).json({ 
        error: '服务器内部错误', 
        message: error.message 
      });
    }
  }
});

// 发射场任务列表API转接
app.get('/api/launch_site_missions/', async (req, res) => {
  try {
    console.log('转接发射场任务列表请求到Django服务器');
    
    const response = await axios.get(`${DJANGO_SERVER_URL}/api/launch_site_missions/`, {
      params: req.query,  // 转发查询参数
      timeout: 10000
    });
    
    res.json(response.data);
  } catch (error) {
    console.error('发射场任务列表API转接错误:', error.message);
    
    if (error.response) {
      res.status(error.response.status).json(error.response.data);
    } else {
      res.status(500).json({ 
        error: '服务器内部错误', 
        message: error.message 
      });
    }
  }
});


// 新增：用户网页内容创建/更新 API
app.post('/api/user_webpage/create/', async (req, res) => {
    try {
        const response = await axios.post(`${DJANGO_SERVER_URL}/user-api/user_webpage/create/`, req.body, {
            headers: {
                'Content-Type': 'application/json'
            },
            timeout: 30000
        });
        res.status(response.status).json(response.data);
    } catch (error) {
        if (error.response) {
            res.status(error.response.status).json(error.response.data);
        } else {
            console.error('Error while creating user webpage:', error.message);
            res.status(500).json({ error: 'Internal Server Error' });
        }
    }
});

// 新增：用户网页内容读取 API
app.get('/api/user_webpage/:user_id/', async (req, res) => {
    try {
        const response = await axios.get(`${DJANGO_SERVER_URL}/user-api/user_webpage/${req.params.user_id}/`, {
            timeout: 30000
        });
        res.status(response.status).json(response.data);
    } catch (error) {
        if (error.response) {
            res.status(error.response.status).json(error.response.data);
        } else {
            console.error('Error while fetching user webpage:', error.message);
            res.status(500).json({ error: 'Internal Server Error' });
        }
    }
});
// 机构详情API转接
app.get('/api/institution_detail/', async (req, res) => {
    try {
        console.log('转接机构详情请求到Django服务器');
        
        // 向 Django 服务器转发请求
        const response = await axios.get(`${DJANGO_SERVER_URL}/api/institution_detail/`, {
            params: req.query,
            timeout: 10000
        });

        // 将 Django 的响应直接返回给前端
        res.status(response.status).json(response.data);
    } catch (error) {
        console.error('机构详情API转接错误:', error.message);
        
        // 处理错误
        if (error.response) {
            // 如果 Django 返回了错误状态码（如 400、404），直接返回给前端
            res.status(error.response.status).json(error.response.data);
        } else {
            // 如果是网络错误或其他问题，返回 500 Internal Server Error
            res.status(500).json({ 
                error: '服务器内部错误', 
                message: error.message 
            });
        }
    }
});
// 添加知识题库API路由
app.get('/api/knowledge_question/', async (req, res) => {
    const questionId = req.query.id;
    if (!questionId) {
        return res.status(400).json({ error: 'ID parameter is required' });
    }

    try {
        const response = await axios.get(`${DJANGO_SERVER_URL}/api/knowledge_question/?id=${questionId}`);
        res.json(response.data);
    } catch (error) {
        console.error('Error fetching knowledge question:', error.message);
        if (error.response) {
            res.status(error.response.status).json({ error: 'Failed to fetch knowledge question' });
        } else {
            res.status(500).json({ error: 'Internal server error' });
        }
    }
});

